/**
 * \file vector4_swizzle.hpp
 * 
 * \section COPYRIGHT
 *
 * Basis: A 3D Mathematics Library
 *
 * ---------------------------------------------------------------------
 *
 * Copyright (c) 2010, Don Olmstead
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *  1. Redistributions of source code must retain the above copyright notice,
 *     this list of conditions and the following disclaimer.
 *
 *  2. Redistributions in binary form must reproduce the above copyright notice,
 *     this list of conditions and the following disclaimer in the documentation
 *     and/or other materials provided with the distribution.
 *
 *  3. Neither the name of organization nor the names of its contributors may be
 *     used to endorse or promote products derived from this software without
 *     specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef BASIS_DETAIL_VECTOR4_SWIZZLE_HPP_INCLUDED
#define BASIS_DETAIL_VECTOR4_SWIZZLE_HPP_INCLUDED

/// Swizzles the vector to { x, x, x, x }
#define xxxx shuffle<0, 0, 0, 0>()
/// Swizzles the vector to { x, x, x, y }
#define xxxy shuffle<0, 0, 0, 1>()
/// Swizzles the vector to { x, x, x, z }
#define xxxz shuffle<0, 0, 0, 2>()
/// Swizzles the vector to { x, x, x, w }
#define xxxw shuffle<0, 0, 0, 3>()
/// Swizzles the vector to { x, x, y, x }
#define xxyx shuffle<0, 0, 1, 0>()
/// Swizzles the vector to { x, x, y, y }
#define xxyy shuffle<0, 0, 1, 1>()
/// Swizzles the vector to { x, x, y, z }
#define xxyz shuffle<0, 0, 1, 2>()
/// Swizzles the vector to { x, x, y, w }
#define xxyw shuffle<0, 0, 1, 3>()
/// Swizzles the vector to { x, x, z, x }
#define xxzx shuffle<0, 0, 2, 0>()
/// Swizzles the vector to { x, x, z, y }
#define xxzy shuffle<0, 0, 2, 1>()
/// Swizzles the vector to { x, x, z, z }
#define xxzz shuffle<0, 0, 2, 2>()
/// Swizzles the vector to { x, x, z, w }
#define xxzw shuffle<0, 0, 2, 3>()
/// Swizzles the vector to { x, x, w, x }
#define xxwx shuffle<0, 0, 3, 0>()
/// Swizzles the vector to { x, x, w, y }
#define xxwy shuffle<0, 0, 3, 1>()
/// Swizzles the vector to { x, x, w, z }
#define xxwz shuffle<0, 0, 3, 2>()
/// Swizzles the vector to { x, x, w, w }
#define xxww shuffle<0, 0, 3, 3>()
/// Swizzles the vector to { x, y, x, x }
#define xyxx shuffle<0, 1, 0, 0>()
/// Swizzles the vector to { x, y, x, y }
#define xyxy shuffle<0, 1, 0, 1>()
/// Swizzles the vector to { x, y, x, z }
#define xyxz shuffle<0, 1, 0, 2>()
/// Swizzles the vector to { x, y, x, w }
#define xyxw shuffle<0, 1, 0, 3>()
/// Swizzles the vector to { x, y, y, x }
#define xyyx shuffle<0, 1, 1, 0>()
/// Swizzles the vector to { x, y, y, y }
#define xyyy shuffle<0, 1, 1, 1>()
/// Swizzles the vector to { x, y, y, z }
#define xyyz shuffle<0, 1, 1, 2>()
/// Swizzles the vector to { x, y, y, w }
#define xyyw shuffle<0, 1, 1, 3>()
/// Swizzles the vector to { x, y, z, x }
#define xyzx shuffle<0, 1, 2, 0>()
/// Swizzles the vector to { x, y, z, y }
#define xyzy shuffle<0, 1, 2, 1>()
/// Swizzles the vector to { x, y, z, z }
#define xyzz shuffle<0, 1, 2, 2>()
/// Swizzles the vector to { x, y, z, w }
#define xyzw shuffle<0, 1, 2, 3>()
/// Swizzles the vector to { x, y, w, x }
#define xywx shuffle<0, 1, 3, 0>()
/// Swizzles the vector to { x, y, w, y }
#define xywy shuffle<0, 1, 3, 1>()
/// Swizzles the vector to { x, y, w, z }
#define xywz shuffle<0, 1, 3, 2>()
/// Swizzles the vector to { x, y, w, w }
#define xyww shuffle<0, 1, 3, 3>()
/// Swizzles the vector to { x, z, x, x }
#define xzxx shuffle<0, 2, 0, 0>()
/// Swizzles the vector to { x, z, x, y }
#define xzxy shuffle<0, 2, 0, 1>()
/// Swizzles the vector to { x, z, x, z }
#define xzxz shuffle<0, 2, 0, 2>()
/// Swizzles the vector to { x, z, x, w }
#define xzxw shuffle<0, 2, 0, 3>()
/// Swizzles the vector to { x, z, y, x }
#define xzyx shuffle<0, 2, 1, 0>()
/// Swizzles the vector to { x, z, y, y }
#define xzyy shuffle<0, 2, 1, 1>()
/// Swizzles the vector to { x, z, y, z }
#define xzyz shuffle<0, 2, 1, 2>()
/// Swizzles the vector to { x, z, y, w }
#define xzyw shuffle<0, 2, 1, 3>()
/// Swizzles the vector to { x, z, z, x }
#define xzzx shuffle<0, 2, 2, 0>()
/// Swizzles the vector to { x, z, z, y }
#define xzzy shuffle<0, 2, 2, 1>()
/// Swizzles the vector to { x, z, z, z }
#define xzzz shuffle<0, 2, 2, 2>()
/// Swizzles the vector to { x, z, z, w }
#define xzzw shuffle<0, 2, 2, 3>()
/// Swizzles the vector to { x, z, w, x }
#define xzwx shuffle<0, 2, 3, 0>()
/// Swizzles the vector to { x, z, w, y }
#define xzwy shuffle<0, 2, 3, 1>()
/// Swizzles the vector to { x, z, w, z }
#define xzwz shuffle<0, 2, 3, 2>()
/// Swizzles the vector to { x, z, w, w }
#define xzww shuffle<0, 2, 3, 3>()
/// Swizzles the vector to { x, w, x, x }
#define xwxx shuffle<0, 3, 0, 0>()
/// Swizzles the vector to { x, w, x, y }
#define xwxy shuffle<0, 3, 0, 1>()
/// Swizzles the vector to { x, w, x, z }
#define xwxz shuffle<0, 3, 0, 2>()
/// Swizzles the vector to { x, w, x, w }
#define xwxw shuffle<0, 3, 0, 3>()
/// Swizzles the vector to { x, w, y, x }
#define xwyx shuffle<0, 3, 1, 0>()
/// Swizzles the vector to { x, w, y, y }
#define xwyy shuffle<0, 3, 1, 1>()
/// Swizzles the vector to { x, w, y, z }
#define xwyz shuffle<0, 3, 1, 2>()
/// Swizzles the vector to { x, w, y, w }
#define xwyw shuffle<0, 3, 1, 3>()
/// Swizzles the vector to { x, w, z, x }
#define xwzx shuffle<0, 3, 2, 0>()
/// Swizzles the vector to { x, w, z, y }
#define xwzy shuffle<0, 3, 2, 1>()
/// Swizzles the vector to { x, w, z, z }
#define xwzz shuffle<0, 3, 2, 2>()
/// Swizzles the vector to { x, w, z, w }
#define xwzw shuffle<0, 3, 2, 3>()
/// Swizzles the vector to { x, w, w, x }
#define xwwx shuffle<0, 3, 3, 0>()
/// Swizzles the vector to { x, w, w, y }
#define xwwy shuffle<0, 3, 3, 1>()
/// Swizzles the vector to { x, w, w, z }
#define xwwz shuffle<0, 3, 3, 2>()
/// Swizzles the vector to { x, w, w, w }
#define xwww shuffle<0, 3, 3, 3>()
/// Swizzles the vector to { y, x, x, x }
#define yxxx shuffle<1, 0, 0, 0>()
/// Swizzles the vector to { y, x, x, y }
#define yxxy shuffle<1, 0, 0, 1>()
/// Swizzles the vector to { y, x, x, z }
#define yxxz shuffle<1, 0, 0, 2>()
/// Swizzles the vector to { y, x, x, w }
#define yxxw shuffle<1, 0, 0, 3>()
/// Swizzles the vector to { y, x, y, x }
#define yxyx shuffle<1, 0, 1, 0>()
/// Swizzles the vector to { y, x, y, y }
#define yxyy shuffle<1, 0, 1, 1>()
/// Swizzles the vector to { y, x, y, z }
#define yxyz shuffle<1, 0, 1, 2>()
/// Swizzles the vector to { y, x, y, w }
#define yxyw shuffle<1, 0, 1, 3>()
/// Swizzles the vector to { y, x, z, x }
#define yxzx shuffle<1, 0, 2, 0>()
/// Swizzles the vector to { y, x, z, y }
#define yxzy shuffle<1, 0, 2, 1>()
/// Swizzles the vector to { y, x, z, z }
#define yxzz shuffle<1, 0, 2, 2>()
/// Swizzles the vector to { y, x, z, w }
#define yxzw shuffle<1, 0, 2, 3>()
/// Swizzles the vector to { y, x, w, x }
#define yxwx shuffle<1, 0, 3, 0>()
/// Swizzles the vector to { y, x, w, y }
#define yxwy shuffle<1, 0, 3, 1>()
/// Swizzles the vector to { y, x, w, z }
#define yxwz shuffle<1, 0, 3, 2>()
/// Swizzles the vector to { y, x, w, w }
#define yxww shuffle<1, 0, 3, 3>()
/// Swizzles the vector to { y, y, x, x }
#define yyxx shuffle<1, 1, 0, 0>()
/// Swizzles the vector to { y, y, x, y }
#define yyxy shuffle<1, 1, 0, 1>()
/// Swizzles the vector to { y, y, x, z }
#define yyxz shuffle<1, 1, 0, 2>()
/// Swizzles the vector to { y, y, x, w }
#define yyxw shuffle<1, 1, 0, 3>()
/// Swizzles the vector to { y, y, y, x }
#define yyyx shuffle<1, 1, 1, 0>()
/// Swizzles the vector to { y, y, y, y }
#define yyyy shuffle<1, 1, 1, 1>()
/// Swizzles the vector to { y, y, y, z }
#define yyyz shuffle<1, 1, 1, 2>()
/// Swizzles the vector to { y, y, y, w }
#define yyyw shuffle<1, 1, 1, 3>()
/// Swizzles the vector to { y, y, z, x }
#define yyzx shuffle<1, 1, 2, 0>()
/// Swizzles the vector to { y, y, z, y }
#define yyzy shuffle<1, 1, 2, 1>()
/// Swizzles the vector to { y, y, z, z }
#define yyzz shuffle<1, 1, 2, 2>()
/// Swizzles the vector to { y, y, z, w }
#define yyzw shuffle<1, 1, 2, 3>()
/// Swizzles the vector to { y, y, w, x }
#define yywx shuffle<1, 1, 3, 0>()
/// Swizzles the vector to { y, y, w, y }
#define yywy shuffle<1, 1, 3, 1>()
/// Swizzles the vector to { y, y, w, z }
#define yywz shuffle<1, 1, 3, 2>()
/// Swizzles the vector to { y, y, w, w }
#define yyww shuffle<1, 1, 3, 3>()
/// Swizzles the vector to { y, z, x, x }
#define yzxx shuffle<1, 2, 0, 0>()
/// Swizzles the vector to { y, z, x, y }
#define yzxy shuffle<1, 2, 0, 1>()
/// Swizzles the vector to { y, z, x, z }
#define yzxz shuffle<1, 2, 0, 2>()
/// Swizzles the vector to { y, z, x, w }
#define yzxw shuffle<1, 2, 0, 3>()
/// Swizzles the vector to { y, z, y, x }
#define yzyx shuffle<1, 2, 1, 0>()
/// Swizzles the vector to { y, z, y, y }
#define yzyy shuffle<1, 2, 1, 1>()
/// Swizzles the vector to { y, z, y, z }
#define yzyz shuffle<1, 2, 1, 2>()
/// Swizzles the vector to { y, z, y, w }
#define yzyw shuffle<1, 2, 1, 3>()
/// Swizzles the vector to { y, z, z, x }
#define yzzx shuffle<1, 2, 2, 0>()
/// Swizzles the vector to { y, z, z, y }
#define yzzy shuffle<1, 2, 2, 1>()
/// Swizzles the vector to { y, z, z, z }
#define yzzz shuffle<1, 2, 2, 2>()
/// Swizzles the vector to { y, z, z, w }
#define yzzw shuffle<1, 2, 2, 3>()
/// Swizzles the vector to { y, z, w, x }
#define yzwx shuffle<1, 2, 3, 0>()
/// Swizzles the vector to { y, z, w, y }
#define yzwy shuffle<1, 2, 3, 1>()
/// Swizzles the vector to { y, z, w, z }
#define yzwz shuffle<1, 2, 3, 2>()
/// Swizzles the vector to { y, z, w, w }
#define yzww shuffle<1, 2, 3, 3>()
/// Swizzles the vector to { y, w, x, x }
#define ywxx shuffle<1, 3, 0, 0>()
/// Swizzles the vector to { y, w, x, y }
#define ywxy shuffle<1, 3, 0, 1>()
/// Swizzles the vector to { y, w, x, z }
#define ywxz shuffle<1, 3, 0, 2>()
/// Swizzles the vector to { y, w, x, w }
#define ywxw shuffle<1, 3, 0, 3>()
/// Swizzles the vector to { y, w, y, x }
#define ywyx shuffle<1, 3, 1, 0>()
/// Swizzles the vector to { y, w, y, y }
#define ywyy shuffle<1, 3, 1, 1>()
/// Swizzles the vector to { y, w, y, z }
#define ywyz shuffle<1, 3, 1, 2>()
/// Swizzles the vector to { y, w, y, w }
#define ywyw shuffle<1, 3, 1, 3>()
/// Swizzles the vector to { y, w, z, x }
#define ywzx shuffle<1, 3, 2, 0>()
/// Swizzles the vector to { y, w, z, y }
#define ywzy shuffle<1, 3, 2, 1>()
/// Swizzles the vector to { y, w, z, z }
#define ywzz shuffle<1, 3, 2, 2>()
/// Swizzles the vector to { y, w, z, w }
#define ywzw shuffle<1, 3, 2, 3>()
/// Swizzles the vector to { y, w, w, x }
#define ywwx shuffle<1, 3, 3, 0>()
/// Swizzles the vector to { y, w, w, y }
#define ywwy shuffle<1, 3, 3, 1>()
/// Swizzles the vector to { y, w, w, z }
#define ywwz shuffle<1, 3, 3, 2>()
/// Swizzles the vector to { y, w, w, w }
#define ywww shuffle<1, 3, 3, 3>()
/// Swizzles the vector to { z, x, x, x }
#define zxxx shuffle<2, 0, 0, 0>()
/// Swizzles the vector to { z, x, x, y }
#define zxxy shuffle<2, 0, 0, 1>()
/// Swizzles the vector to { z, x, x, z }
#define zxxz shuffle<2, 0, 0, 2>()
/// Swizzles the vector to { z, x, x, w }
#define zxxw shuffle<2, 0, 0, 3>()
/// Swizzles the vector to { z, x, y, x }
#define zxyx shuffle<2, 0, 1, 0>()
/// Swizzles the vector to { z, x, y, y }
#define zxyy shuffle<2, 0, 1, 1>()
/// Swizzles the vector to { z, x, y, z }
#define zxyz shuffle<2, 0, 1, 2>()
/// Swizzles the vector to { z, x, y, w }
#define zxyw shuffle<2, 0, 1, 3>()
/// Swizzles the vector to { z, x, z, x }
#define zxzx shuffle<2, 0, 2, 0>()
/// Swizzles the vector to { z, x, z, y }
#define zxzy shuffle<2, 0, 2, 1>()
/// Swizzles the vector to { z, x, z, z }
#define zxzz shuffle<2, 0, 2, 2>()
/// Swizzles the vector to { z, x, z, w }
#define zxzw shuffle<2, 0, 2, 3>()
/// Swizzles the vector to { z, x, w, x }
#define zxwx shuffle<2, 0, 3, 0>()
/// Swizzles the vector to { z, x, w, y }
#define zxwy shuffle<2, 0, 3, 1>()
/// Swizzles the vector to { z, x, w, z }
#define zxwz shuffle<2, 0, 3, 2>()
/// Swizzles the vector to { z, x, w, w }
#define zxww shuffle<2, 0, 3, 3>()
/// Swizzles the vector to { z, y, x, x }
#define zyxx shuffle<2, 1, 0, 0>()
/// Swizzles the vector to { z, y, x, y }
#define zyxy shuffle<2, 1, 0, 1>()
/// Swizzles the vector to { z, y, x, z }
#define zyxz shuffle<2, 1, 0, 2>()
/// Swizzles the vector to { z, y, x, w }
#define zyxw shuffle<2, 1, 0, 3>()
/// Swizzles the vector to { z, y, y, x }
#define zyyx shuffle<2, 1, 1, 0>()
/// Swizzles the vector to { z, y, y, y }
#define zyyy shuffle<2, 1, 1, 1>()
/// Swizzles the vector to { z, y, y, z }
#define zyyz shuffle<2, 1, 1, 2>()
/// Swizzles the vector to { z, y, y, w }
#define zyyw shuffle<2, 1, 1, 3>()
/// Swizzles the vector to { z, y, z, x }
#define zyzx shuffle<2, 1, 2, 0>()
/// Swizzles the vector to { z, y, z, y }
#define zyzy shuffle<2, 1, 2, 1>()
/// Swizzles the vector to { z, y, z, z }
#define zyzz shuffle<2, 1, 2, 2>()
/// Swizzles the vector to { z, y, z, w }
#define zyzw shuffle<2, 1, 2, 3>()
/// Swizzles the vector to { z, y, w, x }
#define zywx shuffle<2, 1, 3, 0>()
/// Swizzles the vector to { z, y, w, y }
#define zywy shuffle<2, 1, 3, 1>()
/// Swizzles the vector to { z, y, w, z }
#define zywz shuffle<2, 1, 3, 2>()
/// Swizzles the vector to { z, y, w, w }
#define zyww shuffle<2, 1, 3, 3>()
/// Swizzles the vector to { z, z, x, x }
#define zzxx shuffle<2, 2, 0, 0>()
/// Swizzles the vector to { z, z, x, y }
#define zzxy shuffle<2, 2, 0, 1>()
/// Swizzles the vector to { z, z, x, z }
#define zzxz shuffle<2, 2, 0, 2>()
/// Swizzles the vector to { z, z, x, w }
#define zzxw shuffle<2, 2, 0, 3>()
/// Swizzles the vector to { z, z, y, x }
#define zzyx shuffle<2, 2, 1, 0>()
/// Swizzles the vector to { z, z, y, y }
#define zzyy shuffle<2, 2, 1, 1>()
/// Swizzles the vector to { z, z, y, z }
#define zzyz shuffle<2, 2, 1, 2>()
/// Swizzles the vector to { z, z, y, w }
#define zzyw shuffle<2, 2, 1, 3>()
/// Swizzles the vector to { z, z, z, x }
#define zzzx shuffle<2, 2, 2, 0>()
/// Swizzles the vector to { z, z, z, y }
#define zzzy shuffle<2, 2, 2, 1>()
/// Swizzles the vector to { z, z, z, z }
#define zzzz shuffle<2, 2, 2, 2>()
/// Swizzles the vector to { z, z, z, w }
#define zzzw shuffle<2, 2, 2, 3>()
/// Swizzles the vector to { z, z, w, x }
#define zzwx shuffle<2, 2, 3, 0>()
/// Swizzles the vector to { z, z, w, y }
#define zzwy shuffle<2, 2, 3, 1>()
/// Swizzles the vector to { z, z, w, z }
#define zzwz shuffle<2, 2, 3, 2>()
/// Swizzles the vector to { z, z, w, w }
#define zzww shuffle<2, 2, 3, 3>()
/// Swizzles the vector to { z, w, x, x }
#define zwxx shuffle<2, 3, 0, 0>()
/// Swizzles the vector to { z, w, x, y }
#define zwxy shuffle<2, 3, 0, 1>()
/// Swizzles the vector to { z, w, x, z }
#define zwxz shuffle<2, 3, 0, 2>()
/// Swizzles the vector to { z, w, x, w }
#define zwxw shuffle<2, 3, 0, 3>()
/// Swizzles the vector to { z, w, y, x }
#define zwyx shuffle<2, 3, 1, 0>()
/// Swizzles the vector to { z, w, y, y }
#define zwyy shuffle<2, 3, 1, 1>()
/// Swizzles the vector to { z, w, y, z }
#define zwyz shuffle<2, 3, 1, 2>()
/// Swizzles the vector to { z, w, y, w }
#define zwyw shuffle<2, 3, 1, 3>()
/// Swizzles the vector to { z, w, z, x }
#define zwzx shuffle<2, 3, 2, 0>()
/// Swizzles the vector to { z, w, z, y }
#define zwzy shuffle<2, 3, 2, 1>()
/// Swizzles the vector to { z, w, z, z }
#define zwzz shuffle<2, 3, 2, 2>()
/// Swizzles the vector to { z, w, z, w }
#define zwzw shuffle<2, 3, 2, 3>()
/// Swizzles the vector to { z, w, w, x }
#define zwwx shuffle<2, 3, 3, 0>()
/// Swizzles the vector to { z, w, w, y }
#define zwwy shuffle<2, 3, 3, 1>()
/// Swizzles the vector to { z, w, w, z }
#define zwwz shuffle<2, 3, 3, 2>()
/// Swizzles the vector to { z, w, w, w }
#define zwww shuffle<2, 3, 3, 3>()
/// Swizzles the vector to { w, x, x, x }
#define wxxx shuffle<3, 0, 0, 0>()
/// Swizzles the vector to { w, x, x, y }
#define wxxy shuffle<3, 0, 0, 1>()
/// Swizzles the vector to { w, x, x, z }
#define wxxz shuffle<3, 0, 0, 2>()
/// Swizzles the vector to { w, x, x, w }
#define wxxw shuffle<3, 0, 0, 3>()
/// Swizzles the vector to { w, x, y, x }
#define wxyx shuffle<3, 0, 1, 0>()
/// Swizzles the vector to { w, x, y, y }
#define wxyy shuffle<3, 0, 1, 1>()
/// Swizzles the vector to { w, x, y, z }
#define wxyz shuffle<3, 0, 1, 2>()
/// Swizzles the vector to { w, x, y, w }
#define wxyw shuffle<3, 0, 1, 3>()
/// Swizzles the vector to { w, x, z, x }
#define wxzx shuffle<3, 0, 2, 0>()
/// Swizzles the vector to { w, x, z, y }
#define wxzy shuffle<3, 0, 2, 1>()
/// Swizzles the vector to { w, x, z, z }
#define wxzz shuffle<3, 0, 2, 2>()
/// Swizzles the vector to { w, x, z, w }
#define wxzw shuffle<3, 0, 2, 3>()
/// Swizzles the vector to { w, x, w, x }
#define wxwx shuffle<3, 0, 3, 0>()
/// Swizzles the vector to { w, x, w, y }
#define wxwy shuffle<3, 0, 3, 1>()
/// Swizzles the vector to { w, x, w, z }
#define wxwz shuffle<3, 0, 3, 2>()
/// Swizzles the vector to { w, x, w, w }
#define wxww shuffle<3, 0, 3, 3>()
/// Swizzles the vector to { w, y, x, x }
#define wyxx shuffle<3, 1, 0, 0>()
/// Swizzles the vector to { w, y, x, y }
#define wyxy shuffle<3, 1, 0, 1>()
/// Swizzles the vector to { w, y, x, z }
#define wyxz shuffle<3, 1, 0, 2>()
/// Swizzles the vector to { w, y, x, w }
#define wyxw shuffle<3, 1, 0, 3>()
/// Swizzles the vector to { w, y, y, x }
#define wyyx shuffle<3, 1, 1, 0>()
/// Swizzles the vector to { w, y, y, y }
#define wyyy shuffle<3, 1, 1, 1>()
/// Swizzles the vector to { w, y, y, z }
#define wyyz shuffle<3, 1, 1, 2>()
/// Swizzles the vector to { w, y, y, w }
#define wyyw shuffle<3, 1, 1, 3>()
/// Swizzles the vector to { w, y, z, x }
#define wyzx shuffle<3, 1, 2, 0>()
/// Swizzles the vector to { w, y, z, y }
#define wyzy shuffle<3, 1, 2, 1>()
/// Swizzles the vector to { w, y, z, z }
#define wyzz shuffle<3, 1, 2, 2>()
/// Swizzles the vector to { w, y, z, w }
#define wyzw shuffle<3, 1, 2, 3>()
/// Swizzles the vector to { w, y, w, x }
#define wywx shuffle<3, 1, 3, 0>()
/// Swizzles the vector to { w, y, w, y }
#define wywy shuffle<3, 1, 3, 1>()
/// Swizzles the vector to { w, y, w, z }
#define wywz shuffle<3, 1, 3, 2>()
/// Swizzles the vector to { w, y, w, w }
#define wyww shuffle<3, 1, 3, 3>()
/// Swizzles the vector to { w, z, x, x }
#define wzxx shuffle<3, 2, 0, 0>()
/// Swizzles the vector to { w, z, x, y }
#define wzxy shuffle<3, 2, 0, 1>()
/// Swizzles the vector to { w, z, x, z }
#define wzxz shuffle<3, 2, 0, 2>()
/// Swizzles the vector to { w, z, x, w }
#define wzxw shuffle<3, 2, 0, 3>()
/// Swizzles the vector to { w, z, y, x }
#define wzyx shuffle<3, 2, 1, 0>()
/// Swizzles the vector to { w, z, y, y }
#define wzyy shuffle<3, 2, 1, 1>()
/// Swizzles the vector to { w, z, y, z }
#define wzyz shuffle<3, 2, 1, 2>()
/// Swizzles the vector to { w, z, y, w }
#define wzyw shuffle<3, 2, 1, 3>()
/// Swizzles the vector to { w, z, z, x }
#define wzzx shuffle<3, 2, 2, 0>()
/// Swizzles the vector to { w, z, z, y }
#define wzzy shuffle<3, 2, 2, 1>()
/// Swizzles the vector to { w, z, z, z }
#define wzzz shuffle<3, 2, 2, 2>()
/// Swizzles the vector to { w, z, z, w }
#define wzzw shuffle<3, 2, 2, 3>()
/// Swizzles the vector to { w, z, w, x }
#define wzwx shuffle<3, 2, 3, 0>()
/// Swizzles the vector to { w, z, w, y }
#define wzwy shuffle<3, 2, 3, 1>()
/// Swizzles the vector to { w, z, w, z }
#define wzwz shuffle<3, 2, 3, 2>()
/// Swizzles the vector to { w, z, w, w }
#define wzww shuffle<3, 2, 3, 3>()
/// Swizzles the vector to { w, w, x, x }
#define wwxx shuffle<3, 3, 0, 0>()
/// Swizzles the vector to { w, w, x, y }
#define wwxy shuffle<3, 3, 0, 1>()
/// Swizzles the vector to { w, w, x, z }
#define wwxz shuffle<3, 3, 0, 2>()
/// Swizzles the vector to { w, w, x, w }
#define wwxw shuffle<3, 3, 0, 3>()
/// Swizzles the vector to { w, w, y, x }
#define wwyx shuffle<3, 3, 1, 0>()
/// Swizzles the vector to { w, w, y, y }
#define wwyy shuffle<3, 3, 1, 1>()
/// Swizzles the vector to { w, w, y, z }
#define wwyz shuffle<3, 3, 1, 2>()
/// Swizzles the vector to { w, w, y, w }
#define wwyw shuffle<3, 3, 1, 3>()
/// Swizzles the vector to { w, w, z, x }
#define wwzx shuffle<3, 3, 2, 0>()
/// Swizzles the vector to { w, w, z, y }
#define wwzy shuffle<3, 3, 2, 1>()
/// Swizzles the vector to { w, w, z, z }
#define wwzz shuffle<3, 3, 2, 2>()
/// Swizzles the vector to { w, w, z, w }
#define wwzw shuffle<3, 3, 2, 3>()
/// Swizzles the vector to { w, w, w, x }
#define wwwx shuffle<3, 3, 3, 0>()
/// Swizzles the vector to { w, w, w, y }
#define wwwy shuffle<3, 3, 3, 1>()
/// Swizzles the vector to { w, w, w, z }
#define wwwz shuffle<3, 3, 3, 2>()
/// Swizzles the vector to { w, w, w, w }
#define wwww shuffle<3, 3, 3, 3>()

#endif // end BASIS_DETAIL_VECTOR4_SWIZZLE_HPP_INCLUDED
